﻿using System;
using System.ComponentModel;
using System.Runtime.InteropServices;
using Teigha.Core;

namespace Teigha.TD
{
	public class OdDbDimension : OdDbEntity
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public OdDbDimension(IntPtr cPtr, bool cMemoryOwn) : base(TD_DbPINVOKE.OdDbDimension_SWIGUpcast(cPtr), cMemoryOwn)
		{
			this.swigCPtr = new HandleRef(this, cPtr);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public static HandleRef getCPtr(OdDbDimension obj)
		{
			if (obj != null)
			{
				return obj.swigCPtr;
			}
			return new HandleRef(null, IntPtr.Zero);
		}

		~OdDbDimension()
		{
			this.Dispose();
		}

		public override void Dispose()
		{
			if (this.swigCPtr.Handle != IntPtr.Zero)
			{
				if (this.swigCMemOwn)
				{
					lock (this.locker)
					{
						if (this.swigCPtr.Handle != IntPtr.Zero && this.swigCMemOwn)
						{
							this.swigCMemOwn = false;
							TD_DbPINVOKE.delete_OdDbDimension(this.swigCPtr);
						}
					}
					this.swigCMemOwn = false;
				}
				this.swigCPtr = new HandleRef(null, IntPtr.Zero);
			}
			GC.SuppressFinalize(this);
			base.Dispose();
		}

		public new static OdDbDimension cast(OdRxObject pObj)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.OdDbDimension_cast(OdRxObject.getCPtr(pObj));
			OdDbDimension result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdDbDimension)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdDbDimension)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdDbDimension)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new static OdRxClass desc()
		{
			OdRxClass result = (OdRxClass)Teigha.Core.Helpers.odrxCreateObjectInternal(TD_DbPINVOKE.OdDbDimension_desc(), false);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual OdRxClass isA()
		{
			OdRxClass result = (OdRxClass)Teigha.Core.Helpers.odrxCreateObjectInternal(TD_DbPINVOKE.OdDbDimension_isA(this.swigCPtr), false);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual OdRxObject queryX(OdRxClass protocolClass)
		{
			OdRxObject result = Teigha.Core.Helpers.odrxCreateObjectInternal(TD_DbPINVOKE.OdDbDimension_queryX(this.swigCPtr, OdRxClass.getCPtr(protocolClass)), false);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new static OdDbDimension createObject()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.OdDbDimension_createObject();
			OdDbDimension result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdDbDimension)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdDbDimension)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdDbDimension)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdGePoint3d textPosition()
		{
			OdGePoint3d result = new OdGePoint3d(TD_DbPINVOKE.OdDbDimension_textPosition(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setTextPosition(OdGePoint3d textPosition)
		{
			TD_DbPINVOKE.OdDbDimension_setTextPosition(this.swigCPtr, OdGePoint3d.getCPtr(textPosition));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public bool isUsingDefaultTextPosition()
		{
			bool result = TD_DbPINVOKE.OdDbDimension_isUsingDefaultTextPosition(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void useSetTextPosition()
		{
			TD_DbPINVOKE.OdDbDimension_useSetTextPosition(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void useDefaultTextPosition()
		{
			TD_DbPINVOKE.OdDbDimension_useDefaultTextPosition(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public OdGeVector3d normal()
		{
			OdGeVector3d result = new OdGeVector3d(TD_DbPINVOKE.OdDbDimension_normal(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setNormal(OdGeVector3d normal)
		{
			TD_DbPINVOKE.OdDbDimension_setNormal(this.swigCPtr, OdGeVector3d.getCPtr(normal));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual bool isPlanar()
		{
			bool result = TD_DbPINVOKE.OdDbDimension_isPlanar(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual OdResult getPlane(OdGePlane plane, out Planarity planarity)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdDbDimension_getPlane(this.swigCPtr, OdGePlane.getCPtr(plane), out planarity);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public double elevation()
		{
			double result = TD_DbPINVOKE.OdDbDimension_elevation(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setElevation(double elevation)
		{
			TD_DbPINVOKE.OdDbDimension_setElevation(this.swigCPtr, elevation);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public string dimensionText()
		{
			string result = TD_DbPINVOKE.OdDbDimension_dimensionText(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setDimensionText(string dimensionText)
		{
			TD_DbPINVOKE.OdDbDimension_setDimensionText(this.swigCPtr, dimensionText);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public double textRotation()
		{
			double result = TD_DbPINVOKE.OdDbDimension_textRotation(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setTextRotation(double textRotation)
		{
			TD_DbPINVOKE.OdDbDimension_setTextRotation(this.swigCPtr, textRotation);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public OdDbObjectId dimensionStyle()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDimension_dimensionStyle(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setDimensionStyle(OdDbObjectId objectID)
		{
			TD_DbPINVOKE.OdDbDimension_setDimensionStyle(this.swigCPtr, OdDbObjectId.getCPtr(objectID));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public OdDbMText.AttachmentPoint textAttachment()
		{
			OdDbMText.AttachmentPoint result = (OdDbMText.AttachmentPoint)TD_DbPINVOKE.OdDbDimension_textAttachment(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setTextAttachment(OdDbMText.AttachmentPoint attachmentPoint)
		{
			TD_DbPINVOKE.OdDbDimension_setTextAttachment(this.swigCPtr, (int)attachmentPoint);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public LineSpacingStyle textLineSpacingStyle()
		{
			LineSpacingStyle result = (LineSpacingStyle)TD_DbPINVOKE.OdDbDimension_textLineSpacingStyle(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setTextLineSpacingStyle(LineSpacingStyle lineSpacingStyle)
		{
			TD_DbPINVOKE.OdDbDimension_setTextLineSpacingStyle(this.swigCPtr, (int)lineSpacingStyle);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public double textLineSpacingFactor()
		{
			double result = TD_DbPINVOKE.OdDbDimension_textLineSpacingFactor(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setTextLineSpacingFactor(double lineSpacingFactor)
		{
			TD_DbPINVOKE.OdDbDimension_setTextLineSpacingFactor(this.swigCPtr, lineSpacingFactor);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void getDimstyleData(OdDbDimStyleTableRecord pRecord)
		{
			TD_DbPINVOKE.OdDbDimension_getDimstyleData(this.swigCPtr, OdDbDimStyleTableRecord.getCPtr(pRecord));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void setDimstyleData(OdDbDimStyleTableRecord pDimstyle)
		{
			TD_DbPINVOKE.OdDbDimension_setDimstyleData__SWIG_0(this.swigCPtr, OdDbDimStyleTableRecord.getCPtr(pDimstyle));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void setDimstyleData(OdDbObjectId dimstyleID)
		{
			TD_DbPINVOKE.OdDbDimension_setDimstyleData__SWIG_1(this.swigCPtr, OdDbObjectId.getCPtr(dimstyleID));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public double horizontalRotation()
		{
			double result = TD_DbPINVOKE.OdDbDimension_horizontalRotation(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setHorizontalRotation(double horizontalRotation)
		{
			TD_DbPINVOKE.OdDbDimension_setHorizontalRotation(this.swigCPtr, horizontalRotation);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public OdDbObjectId dimBlockId()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDimension_dimBlockId(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setDimBlockId(OdDbObjectId dimBlockId, bool singleReferenced)
		{
			TD_DbPINVOKE.OdDbDimension_setDimBlockId__SWIG_0(this.swigCPtr, OdDbObjectId.getCPtr(dimBlockId), singleReferenced);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void setDimBlockId(OdDbObjectId dimBlockId)
		{
			TD_DbPINVOKE.OdDbDimension_setDimBlockId__SWIG_1(this.swigCPtr, OdDbObjectId.getCPtr(dimBlockId));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public bool isSingleDimBlockReference()
		{
			bool result = TD_DbPINVOKE.OdDbDimension_isSingleDimBlockReference(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdGePoint3d dimBlockPosition()
		{
			OdGePoint3d result = new OdGePoint3d(TD_DbPINVOKE.OdDbDimension_dimBlockPosition(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setDimBlockPosition(OdGePoint3d dimBlockPosition)
		{
			TD_DbPINVOKE.OdDbDimension_setDimBlockPosition(this.swigCPtr, OdGePoint3d.getCPtr(dimBlockPosition));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public double dimBlockRotation()
		{
			double result = TD_DbPINVOKE.OdDbDimension_dimBlockRotation(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setDimBlockRotation(double dimBlockRotation)
		{
			TD_DbPINVOKE.OdDbDimension_setDimBlockRotation(this.swigCPtr, dimBlockRotation);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public OdGeScale3d dimBlockScale()
		{
			OdGeScale3d result = new OdGeScale3d(TD_DbPINVOKE.OdDbDimension_dimBlockScale(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setDimBlockScale(OdGeScale3d dimBlockScale)
		{
			TD_DbPINVOKE.OdDbDimension_setDimBlockScale(this.swigCPtr, OdGeScale3d.getCPtr(dimBlockScale));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public OdGeMatrix3d dimBlockTransform()
		{
			OdGeMatrix3d result = new OdGeMatrix3d(TD_DbPINVOKE.OdDbDimension_dimBlockTransform(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void recomputeDimBlock(bool forceUpdate)
		{
			TD_DbPINVOKE.OdDbDimension_recomputeDimBlock__SWIG_0(this.swigCPtr, forceUpdate);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void recomputeDimBlock()
		{
			TD_DbPINVOKE.OdDbDimension_recomputeDimBlock__SWIG_1(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public double getMeasurement()
		{
			double result = TD_DbPINVOKE.OdDbDimension_getMeasurement(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public double measurement()
		{
			double result = TD_DbPINVOKE.OdDbDimension_measurement(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public ushort getBgrndTxtColor(OdCmColor bgrndTxtColor)
		{
			ushort result = TD_DbPINVOKE.OdDbDimension_getBgrndTxtColor(this.swigCPtr, OdCmColor.getCPtr(bgrndTxtColor));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setBgrndTxtColor(OdCmColor bgrndTxtColor, ushort bgrndTxtFlags)
		{
			TD_DbPINVOKE.OdDbDimension_setBgrndTxtColor(this.swigCPtr, OdCmColor.getCPtr(bgrndTxtColor), bgrndTxtFlags);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public bool getExtLineFixLenEnable()
		{
			bool result = TD_DbPINVOKE.OdDbDimension_getExtLineFixLenEnable(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setExtLineFixLenEnable(bool extLineFixLenEnable)
		{
			TD_DbPINVOKE.OdDbDimension_setExtLineFixLenEnable(this.swigCPtr, extLineFixLenEnable);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public double getExtLineFixLen()
		{
			double result = TD_DbPINVOKE.OdDbDimension_getExtLineFixLen(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setExtLineFixLen(double extLineFixLen)
		{
			TD_DbPINVOKE.OdDbDimension_setExtLineFixLen(this.swigCPtr, extLineFixLen);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public OdDbObjectId getDimLinetype()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDimension_getDimLinetype(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setDimLinetype(OdDbObjectId linetypeId)
		{
			TD_DbPINVOKE.OdDbDimension_setDimLinetype(this.swigCPtr, OdDbObjectId.getCPtr(linetypeId));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public OdDbObjectId getDimExt1Linetype()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDimension_getDimExt1Linetype(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setDimExt1Linetype(OdDbObjectId linetypeId)
		{
			TD_DbPINVOKE.OdDbDimension_setDimExt1Linetype(this.swigCPtr, OdDbObjectId.getCPtr(linetypeId));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public OdDbObjectId getDimExt2Linetype()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDimension_getDimExt2Linetype(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setDimExt2Linetype(OdDbObjectId linetypeId)
		{
			TD_DbPINVOKE.OdDbDimension_setDimExt2Linetype(this.swigCPtr, OdDbObjectId.getCPtr(linetypeId));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public bool getArrowFirstIsFlipped()
		{
			bool result = TD_DbPINVOKE.OdDbDimension_getArrowFirstIsFlipped(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool getArrowSecondIsFlipped()
		{
			bool result = TD_DbPINVOKE.OdDbDimension_getArrowSecondIsFlipped(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setArrowFirstIsFlipped(bool bIsFlipped)
		{
			TD_DbPINVOKE.OdDbDimension_setArrowFirstIsFlipped(this.swigCPtr, bIsFlipped);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void setArrowSecondIsFlipped(bool bIsFlipped)
		{
			TD_DbPINVOKE.OdDbDimension_setArrowSecondIsFlipped(this.swigCPtr, bIsFlipped);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public bool inspection()
		{
			bool result = TD_DbPINVOKE.OdDbDimension_inspection(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setInspection(bool val)
		{
			TD_DbPINVOKE.OdDbDimension_setInspection(this.swigCPtr, val);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public int inspectionFrame()
		{
			int result = TD_DbPINVOKE.OdDbDimension_inspectionFrame(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setInspectionFrame(int frame)
		{
			TD_DbPINVOKE.OdDbDimension_setInspectionFrame(this.swigCPtr, frame);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public string inspectionLabel()
		{
			string result = TD_DbPINVOKE.OdDbDimension_inspectionLabel(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setInspectionLabel(string label)
		{
			TD_DbPINVOKE.OdDbDimension_setInspectionLabel(this.swigCPtr, label);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public string inspectionRate()
		{
			string result = TD_DbPINVOKE.OdDbDimension_inspectionRate(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setInspectionRate(string label)
		{
			TD_DbPINVOKE.OdDbDimension_setInspectionRate(this.swigCPtr, label);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual OdResult dwgInFields(OdDbDwgFiler pFiler)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdDbDimension_dwgInFields(this.swigCPtr, OdDbDwgFiler.getCPtr(pFiler));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual void dwgOutFields(OdDbDwgFiler pFiler)
		{
			TD_DbPINVOKE.OdDbDimension_dwgOutFields(this.swigCPtr, OdDbDwgFiler.getCPtr(pFiler));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual OdResult dxfInFields(OdDbDxfFiler pFiler)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdDbDimension_dxfInFields(this.swigCPtr, OdDbDxfFiler.getCPtr(pFiler));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual void dxfOutFields(OdDbDxfFiler pFiler)
		{
			TD_DbPINVOKE.OdDbDimension_dxfOutFields(this.swigCPtr, OdDbDxfFiler.getCPtr(pFiler));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual OdResult dxfInFields_R12(OdDbDxfFiler pFiler)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdDbDimension_dxfInFields_R12(this.swigCPtr, OdDbDxfFiler.getCPtr(pFiler));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual void dxfOutFields_R12(OdDbDxfFiler pFiler)
		{
			TD_DbPINVOKE.OdDbDimension_dxfOutFields_R12(this.swigCPtr, OdDbDxfFiler.getCPtr(pFiler));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual OdResult subGetClassID(IntPtr pClsid)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdDbDimension_subGetClassID(this.swigCPtr, pClsid);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual uint subSetAttributes(OdGiDrawableTraits pTraits)
		{
			uint result = TD_DbPINVOKE.OdDbDimension_subSetAttributes(this.swigCPtr, OdGiDrawableTraits.getCPtr(pTraits));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual bool subWorldDraw(OdGiWorldDraw pWd)
		{
			bool result = TD_DbPINVOKE.OdDbDimension_subWorldDraw(this.swigCPtr, OdGiWorldDraw.getCPtr(pWd));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual void subViewportDraw(OdGiViewportDraw pVd)
		{
			TD_DbPINVOKE.OdDbDimension_subViewportDraw(this.swigCPtr, OdGiViewportDraw.getCPtr(pVd));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual OdResult subExplode(OdRxObjectPtrArray entitySet)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdDbDimension_subExplode(this.swigCPtr, OdRxObjectPtrArray.getCPtr(entitySet));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual void subClose()
		{
			TD_DbPINVOKE.OdDbDimension_subClose(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual void modified(OdDbObject pObject)
		{
			TD_DbPINVOKE.OdDbDimension_modified(this.swigCPtr, OdDbObject.getCPtr(pObject));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual OdResult subTransformBy(OdGeMatrix3d xfm)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdDbDimension_subTransformBy(this.swigCPtr, OdGeMatrix3d.getCPtr(xfm));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual OdResult subGetTransformedCopy(OdGeMatrix3d xfm, out OdDbEntity pCopy)
		{
			IntPtr zero = IntPtr.Zero;
			OdResult result;
			try
			{
				OdResult odResult = (OdResult)TD_DbPINVOKE.OdDbDimension_subGetTransformedCopy(this.swigCPtr, OdGeMatrix3d.getCPtr(xfm), out zero);
				if (TD_DbPINVOKE.SWIGPendingException.Pending)
				{
					throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
				}
				result = odResult;
			}
			finally
			{
				pCopy = (OdDbEntity)Teigha.Core.Helpers.odrxCreateObjectInternal(zero, true);
			}
			return result;
		}

		public new virtual void subSetDatabaseDefaults(OdDbDatabase pDb, bool doSubents)
		{
			TD_DbPINVOKE.OdDbDimension_subSetDatabaseDefaults(this.swigCPtr, OdDbDatabase.getCPtr(pDb), doSubents);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual void appendToOwner(OdDbIdPair idPair, OdDbObject pOwnerObject, OdDbIdMapping ownerIdMap)
		{
			TD_DbPINVOKE.OdDbDimension_appendToOwner(this.swigCPtr, OdDbIdPair.getCPtr(idPair), OdDbObject.getCPtr(pOwnerObject), OdDbIdMapping.getCPtr(ownerIdMap));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual OdDbObject subWblockClone(OdDbIdMapping ownerIdMap, OdDbObject arg1)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.OdDbDimension_subWblockClone(this.swigCPtr, OdDbIdMapping.getCPtr(ownerIdMap), OdDbObject.getCPtr(arg1));
			OdDbObject result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdDbObject)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdDbObject)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdDbObject)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void formatMeasurement(ref string formattedMeasurement, double measurementValue, string dimensionText)
		{
			IntPtr intPtr = Marshal.StringToCoTaskMemUni(formattedMeasurement);
			IntPtr value = intPtr;
			try
			{
				TD_DbPINVOKE.OdDbDimension_formatMeasurement(this.swigCPtr, ref intPtr, measurementValue, dimensionText);
				if (TD_DbPINVOKE.SWIGPendingException.Pending)
				{
					throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
				}
			}
			finally
			{
				if (intPtr != value)
				{
					formattedMeasurement = Marshal.PtrToStringUni(intPtr);
				}
			}
		}

		public new virtual OdResult explodeGeometry(OdRxObjectPtrArray entitySet)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdDbDimension_explodeGeometry(this.swigCPtr, OdRxObjectPtrArray.getCPtr(entitySet));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObject dimBlock(OpenMode openMode)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.OdDbDimension_dimBlock__SWIG_0(this.swigCPtr, (int)openMode);
			OdDbObject result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdDbObject)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdDbObject)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdDbObject)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObject dimBlock()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.OdDbDimension_dimBlock__SWIG_1(this.swigCPtr);
			OdDbObject result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdDbObject)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdDbObject)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdDbObject)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual OdResult subGetCompoundObjectTransform(OdGeMatrix3d xM)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdDbDimension_subGetCompoundObjectTransform(this.swigCPtr, OdGeMatrix3d.getCPtr(xM));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool isDynamicDimension()
		{
			bool result = TD_DbPINVOKE.OdDbDimension_isDynamicDimension(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setDynamicDimension(bool bDynamic)
		{
			TD_DbPINVOKE.OdDbDimension_setDynamicDimension(this.swigCPtr, bDynamic);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public bool isConstraintObject()
		{
			bool result = TD_DbPINVOKE.OdDbDimension_isConstraintObject__SWIG_0(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdResult isConstraintObject(out bool isConstraintObject, out bool hasExpression, out bool isReferenceConstraint)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdDbDimension_isConstraintObject__SWIG_1(this.swigCPtr, out isConstraintObject, out hasExpression, out isReferenceConstraint);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool isConstraintDynamic()
		{
			bool result = TD_DbPINVOKE.OdDbDimension_isConstraintDynamic(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdResult setConstraintDynamic(bool bDynamic)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdDbDimension_setConstraintDynamic(this.swigCPtr, bDynamic);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool shouldParticipateInOPM()
		{
			bool result = TD_DbPINVOKE.OdDbDimension_shouldParticipateInOPM(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setShouldParticipateInOPM(bool bShouldParticipate)
		{
			TD_DbPINVOKE.OdDbDimension_setShouldParticipateInOPM(this.swigCPtr, bShouldParticipate);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void setDIMTALN(bool val)
		{
			TD_DbPINVOKE.OdDbDimension_setDIMTALN(this.swigCPtr, val);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public bool getDIMTALN()
		{
			bool result = TD_DbPINVOKE.OdDbDimension_getDIMTALN(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void removeTextField()
		{
			TD_DbPINVOKE.OdDbDimension_removeTextField(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void fieldToMText(out OdDbMText pDimMText)
		{
			IntPtr zero = IntPtr.Zero;
			try
			{
				TD_DbPINVOKE.OdDbDimension_fieldToMText(this.swigCPtr, out zero);
				if (TD_DbPINVOKE.SWIGPendingException.Pending)
				{
					throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
				}
			}
			finally
			{
				pDimMText = (OdDbMText)Teigha.Core.Helpers.odrxCreateObjectInternal(zero, true);
			}
		}

		public void fieldFromMText(out OdDbMText pDimMText)
		{
			IntPtr zero = IntPtr.Zero;
			try
			{
				TD_DbPINVOKE.OdDbDimension_fieldFromMText(this.swigCPtr, out zero);
				if (TD_DbPINVOKE.SWIGPendingException.Pending)
				{
					throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
				}
			}
			finally
			{
				pDimMText = (OdDbMText)Teigha.Core.Helpers.odrxCreateObjectInternal(zero, true);
			}
		}

		public new virtual OdGeMatrix3d getEcs()
		{
			OdGeMatrix3d result = new OdGeMatrix3d(TD_DbPINVOKE.OdDbDimension_getEcs(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void resetTextDefinedSize()
		{
			TD_DbPINVOKE.OdDbDimension_resetTextDefinedSize(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void setTextDefinedSize(double width, double height)
		{
			TD_DbPINVOKE.OdDbDimension_setTextDefinedSize(this.swigCPtr, width, height);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void textDefinedSize(out double width, out double height)
		{
			TD_DbPINVOKE.OdDbDimension_textDefinedSize(this.swigCPtr, out width, out height);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void setDimadec(short var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimadec(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short dimadec()
		{
			short result = TD_DbPINVOKE.OdDbDimension_dimadec(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimalt(bool var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimalt(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool dimalt()
		{
			bool result = TD_DbPINVOKE.OdDbDimension_dimalt(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimaltd(ushort var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimaltd(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual ushort dimaltd()
		{
			ushort result = TD_DbPINVOKE.OdDbDimension_dimaltd(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimaltf(double var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimaltf(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double dimaltf()
		{
			double result = TD_DbPINVOKE.OdDbDimension_dimaltf(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimaltrnd(double var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimaltrnd(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double dimaltrnd()
		{
			double result = TD_DbPINVOKE.OdDbDimension_dimaltrnd(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimalttd(short var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimalttd(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short dimalttd()
		{
			short result = TD_DbPINVOKE.OdDbDimension_dimalttd(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimalttz(byte var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimalttz(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual byte dimalttz()
		{
			byte result = TD_DbPINVOKE.OdDbDimension_dimalttz(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimaltu(short var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimaltu(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short dimaltu()
		{
			short result = TD_DbPINVOKE.OdDbDimension_dimaltu(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimaltz(byte var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimaltz(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual byte dimaltz()
		{
			byte result = TD_DbPINVOKE.OdDbDimension_dimaltz(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimapost(string var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimapost(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual string dimapost()
		{
			string result = TD_DbPINVOKE.OdDbDimension_dimapost(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimasz(double var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimasz(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double dimasz()
		{
			double result = TD_DbPINVOKE.OdDbDimension_dimasz(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimatfit(short var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimatfit(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short dimatfit()
		{
			short result = TD_DbPINVOKE.OdDbDimension_dimatfit(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimaunit(short var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimaunit(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short dimaunit()
		{
			short result = TD_DbPINVOKE.OdDbDimension_dimaunit(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimazin(short var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimazin(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short dimazin()
		{
			short result = TD_DbPINVOKE.OdDbDimension_dimazin(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimblk(OdDbHardPointerId var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimblk(this.swigCPtr, OdDbHardPointerId.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdDbHardPointerId dimblk()
		{
			OdDbHardPointerId result = new OdDbHardPointerId(TD_DbPINVOKE.OdDbDimension_dimblk(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimblk1(OdDbHardPointerId var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimblk1(this.swigCPtr, OdDbHardPointerId.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdDbHardPointerId dimblk1()
		{
			OdDbHardPointerId result = new OdDbHardPointerId(TD_DbPINVOKE.OdDbDimension_dimblk1(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimblk2(OdDbHardPointerId var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimblk2(this.swigCPtr, OdDbHardPointerId.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdDbHardPointerId dimblk2()
		{
			OdDbHardPointerId result = new OdDbHardPointerId(TD_DbPINVOKE.OdDbDimension_dimblk2(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimcen(double var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimcen(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double dimcen()
		{
			double result = TD_DbPINVOKE.OdDbDimension_dimcen(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimclrd(OdCmColor var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimclrd(this.swigCPtr, OdCmColor.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdCmColor dimclrd()
		{
			OdCmColor result = new OdCmColor(TD_DbPINVOKE.OdDbDimension_dimclrd(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimclre(OdCmColor var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimclre(this.swigCPtr, OdCmColor.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdCmColor dimclre()
		{
			OdCmColor result = new OdCmColor(TD_DbPINVOKE.OdDbDimension_dimclre(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimclrt(OdCmColor var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimclrt(this.swigCPtr, OdCmColor.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdCmColor dimclrt()
		{
			OdCmColor result = new OdCmColor(TD_DbPINVOKE.OdDbDimension_dimclrt(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimdec(short var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimdec(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short dimdec()
		{
			short result = TD_DbPINVOKE.OdDbDimension_dimdec(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimdle(double var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimdle(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double dimdle()
		{
			double result = TD_DbPINVOKE.OdDbDimension_dimdle(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimdli(double var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimdli(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double dimdli()
		{
			double result = TD_DbPINVOKE.OdDbDimension_dimdli(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimdsep(short var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimdsep(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short dimdsep()
		{
			short result = TD_DbPINVOKE.OdDbDimension_dimdsep(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimexe(double var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimexe(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double dimexe()
		{
			double result = TD_DbPINVOKE.OdDbDimension_dimexe(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimexo(double var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimexo(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double dimexo()
		{
			double result = TD_DbPINVOKE.OdDbDimension_dimexo(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimfrac(short var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimfrac(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short dimfrac()
		{
			short result = TD_DbPINVOKE.OdDbDimension_dimfrac(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimgap(double var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimgap(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double dimgap()
		{
			double result = TD_DbPINVOKE.OdDbDimension_dimgap(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimjust(ushort var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimjust(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual ushort dimjust()
		{
			ushort result = TD_DbPINVOKE.OdDbDimension_dimjust(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimldrblk(OdDbHardPointerId var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimldrblk(this.swigCPtr, OdDbHardPointerId.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdDbHardPointerId dimldrblk()
		{
			OdDbHardPointerId result = new OdDbHardPointerId(TD_DbPINVOKE.OdDbDimension_dimldrblk(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimlfac(double var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimlfac(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double dimlfac()
		{
			double result = TD_DbPINVOKE.OdDbDimension_dimlfac(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimlim(bool var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimlim(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool dimlim()
		{
			bool result = TD_DbPINVOKE.OdDbDimension_dimlim(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimlunit(short var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimlunit(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short dimlunit()
		{
			short result = TD_DbPINVOKE.OdDbDimension_dimlunit(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimlwd(LineWeight var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimlwd(this.swigCPtr, (int)var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual LineWeight dimlwd()
		{
			LineWeight result = (LineWeight)TD_DbPINVOKE.OdDbDimension_dimlwd(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimlwe(LineWeight var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimlwe(this.swigCPtr, (int)var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual LineWeight dimlwe()
		{
			LineWeight result = (LineWeight)TD_DbPINVOKE.OdDbDimension_dimlwe(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimpost(string var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimpost(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual string dimpost()
		{
			string result = TD_DbPINVOKE.OdDbDimension_dimpost(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimrnd(double var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimrnd(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double dimrnd()
		{
			double result = TD_DbPINVOKE.OdDbDimension_dimrnd(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimsah(bool var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimsah(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool dimsah()
		{
			bool result = TD_DbPINVOKE.OdDbDimension_dimsah(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimscale(double var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimscale(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double dimscale()
		{
			double result = TD_DbPINVOKE.OdDbDimension_dimscale(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimsd1(bool var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimsd1(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool dimsd1()
		{
			bool result = TD_DbPINVOKE.OdDbDimension_dimsd1(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimsd2(bool var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimsd2(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool dimsd2()
		{
			bool result = TD_DbPINVOKE.OdDbDimension_dimsd2(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimse1(bool var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimse1(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool dimse1()
		{
			bool result = TD_DbPINVOKE.OdDbDimension_dimse1(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimse2(bool var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimse2(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool dimse2()
		{
			bool result = TD_DbPINVOKE.OdDbDimension_dimse2(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimsoxd(bool var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimsoxd(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool dimsoxd()
		{
			bool result = TD_DbPINVOKE.OdDbDimension_dimsoxd(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimtad(short var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimtad(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short dimtad()
		{
			short result = TD_DbPINVOKE.OdDbDimension_dimtad(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimtdec(short var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimtdec(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short dimtdec()
		{
			short result = TD_DbPINVOKE.OdDbDimension_dimtdec(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimtfac(double var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimtfac(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double dimtfac()
		{
			double result = TD_DbPINVOKE.OdDbDimension_dimtfac(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimtih(bool var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimtih(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool dimtih()
		{
			bool result = TD_DbPINVOKE.OdDbDimension_dimtih(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimtix(bool var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimtix(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool dimtix()
		{
			bool result = TD_DbPINVOKE.OdDbDimension_dimtix(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimtm(double var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimtm(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double dimtm()
		{
			double result = TD_DbPINVOKE.OdDbDimension_dimtm(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimtmove(short var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimtmove(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short dimtmove()
		{
			short result = TD_DbPINVOKE.OdDbDimension_dimtmove(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimtofl(bool var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimtofl(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool dimtofl()
		{
			bool result = TD_DbPINVOKE.OdDbDimension_dimtofl(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimtoh(bool var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimtoh(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool dimtoh()
		{
			bool result = TD_DbPINVOKE.OdDbDimension_dimtoh(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimtol(bool var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimtol(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool dimtol()
		{
			bool result = TD_DbPINVOKE.OdDbDimension_dimtol(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimtolj(byte var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimtolj(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual byte dimtolj()
		{
			byte result = TD_DbPINVOKE.OdDbDimension_dimtolj(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimtp(double var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimtp(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double dimtp()
		{
			double result = TD_DbPINVOKE.OdDbDimension_dimtp(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimtsz(double var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimtsz(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double dimtsz()
		{
			double result = TD_DbPINVOKE.OdDbDimension_dimtsz(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimtvp(double var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimtvp(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double dimtvp()
		{
			double result = TD_DbPINVOKE.OdDbDimension_dimtvp(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimtxsty(OdDbObjectId var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimtxsty(this.swigCPtr, OdDbObjectId.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdDbObjectId dimtxsty()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDimension_dimtxsty(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimtxt(double var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimtxt(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double dimtxt()
		{
			double result = TD_DbPINVOKE.OdDbDimension_dimtxt(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimtzin(byte var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimtzin(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual byte dimtzin()
		{
			byte result = TD_DbPINVOKE.OdDbDimension_dimtzin(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimupt(bool var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimupt(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool dimupt()
		{
			bool result = TD_DbPINVOKE.OdDbDimension_dimupt(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimzin(byte var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimzin(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual byte dimzin()
		{
			byte result = TD_DbPINVOKE.OdDbDimension_dimzin(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimfxl(double var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimfxl(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double dimfxl()
		{
			double result = TD_DbPINVOKE.OdDbDimension_dimfxl(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimfxlon(bool var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimfxlon(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool dimfxlon()
		{
			bool result = TD_DbPINVOKE.OdDbDimension_dimfxlon(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimjogang(double var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimjogang(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double dimjogang()
		{
			double result = TD_DbPINVOKE.OdDbDimension_dimjogang(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimtfill(short var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimtfill(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short dimtfill()
		{
			short result = TD_DbPINVOKE.OdDbDimension_dimtfill(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimtfillclr(OdCmColor var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimtfillclr(this.swigCPtr, OdCmColor.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdCmColor dimtfillclr()
		{
			OdCmColor result = new OdCmColor(TD_DbPINVOKE.OdDbDimension_dimtfillclr(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimarcsym(short var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimarcsym(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual short dimarcsym()
		{
			short result = TD_DbPINVOKE.OdDbDimension_dimarcsym(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimltype(OdDbObjectId var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimltype(this.swigCPtr, OdDbObjectId.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdDbObjectId dimltype()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDimension_dimltype(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimltex1(OdDbObjectId var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimltex1(this.swigCPtr, OdDbObjectId.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdDbObjectId dimltex1()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDimension_dimltex1(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimltex2(OdDbObjectId var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimltex2(this.swigCPtr, OdDbObjectId.getCPtr(var));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdDbObjectId dimltex2()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbDimension_dimltex2(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimtxtdirection(bool var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimtxtdirection(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool dimtxtdirection()
		{
			bool result = TD_DbPINVOKE.OdDbDimension_dimtxtdirection(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimmzf(double var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimmzf(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double dimmzf()
		{
			double result = TD_DbPINVOKE.OdDbDimension_dimmzf(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimmzs(string var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimmzs(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual string dimmzs()
		{
			string result = TD_DbPINVOKE.OdDbDimension_dimmzs(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimaltmzf(double var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimaltmzf(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double dimaltmzf()
		{
			double result = TD_DbPINVOKE.OdDbDimension_dimaltmzf(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDimaltmzs(string var)
		{
			TD_DbPINVOKE.OdDbDimension_setDimaltmzs(this.swigCPtr, var);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual string dimaltmzs()
		{
			string result = TD_DbPINVOKE.OdDbDimension_dimaltmzs(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		private object locker = new object();

		private HandleRef swigCPtr;

		[Flags]
		public enum DimInspect
		{
			kShapeRemove = 0,
			kShapeRound = 1,
			kShapeAngular = 2,
			kShapeNone = 4,
			kShapeLabel = 16,
			kShapeRate = 32
		}
	}
}
